/**
 * @Auther: csp1999
 * @Date: 2021/01/18/16:04
 * @Description: 搜索微服务SkuService接口实现类
 */
@Service
public class SkuEsServiceImpl implements SkuEsService {

    @Autowired
    private SkuEsMapper skuEsMapper;

    @Autowired
    private SkuFeign skuFeign;

    @Autowired
    private ElasticsearchRestTemplate elasticsearchRestTemplate;

    @Autowired
    private RestHighLevelClient restHighLevelClient;

    /**
     * 将数据库中的全部Sku数据导入ES中
     */
    @Override
    public void importDataToElasticSearch(int start, int end) {
        // 调用Feign,查询List<Sku>
        Result<List<Sku>> skuListResult = skuFeign.findAll(start, end);

        // 将List<Sku>转成List<SkuInfo>
        // JSON.toJSONString(skuListResult.getData()): 将skuListResult中的List<Sku>转成json格式
        // JSON.parseArray(): 将json格式的List<Sku>转成List<SkuInfo>集合
        List<SkuInfo> skuInfoList = JSON.parseArray(JSON.toJSONString(skuListResult.getData()), SkuInfo.class);

        // 遍历当前skuInfoList
        for (SkuInfo skuInfo : skuInfoList) {

            // 获取spec(String类型的Map数据) -> 将其转成 Map类型 ->{'颜色': '梵高星空典藏版', '版本': '8GB+128GB'}
            Map<String, Object> specMap = JSON.parseObject(skuInfo.getSpec(), Map.class);
            // 给skuInfo中的specMap属性赋值
            // 当前Map<String,Object> 的值Object会被作为Sku对象该域（key）对应的值
            skuInfo.setSpecMap(specMap);
        }

        // 调用Mapper 实现数据批量导入
        skuEsMapper.saveAll(skuInfoList);
    }

    /**
     * 根据条件搜索：多条件搜索
     *
//     * @param searchParamMap
     * @return
     */
    @Deprecated // 已被优化,不再使用该方法，其功能被search(Map<String, String> searchParamMap)方法替代
    public Map<String, Object> search2(Map<String, String> searchParamMap) {

        // 1.构建搜索条件：搜索条件构造器(后期有多个检索条件，专门封装一个方法)
        NativeSearchQueryBuilder searchQueryBuilder = new NativeSearchQueryBuilder();
//        if (searchParamMap != null && searchParamMap.size() > 0) {
        // 根据关键词搜索
        String keywords = searchParamMap.get("keywords");

        if (StringUtils.isEmpty(keywords)) {
            keywords = "手机";// 赋值一个keywords默认的值
        }

        // 如果关键词不为空，则搜索关键词数据
        if (!StringUtils.isEmpty(keywords)) {
            searchQueryBuilder.withQuery(
                    QueryBuilders.matchPhraseQuery("name", keywords)
                    // 多个字段匹配搜索关键词
//                    QueryBuilders.multiMatchQuery(keywords, "name.keyword", "categoryName.keyword", "brandNam.keyword")
                    // 不能使用：QueryBuilders.matchQuery("name", keywords) ，这样会导致：
                    // 搜索华为 ---> 华    为 二字可以拆分查询，而matchPhraseQuery 是不可以拆分的
            );
        }

        // 根据分类名称对结果集进行分组：[手机，交换机]
        // 添加聚合查询操作：相当于sql的分组查询（去重复）--->SELECT category_name FROM `tb_sku` WHERE `name` LIKE '%华为%' GROUP BY category_name
        // 得到分类名称数据集合：
        //              category_name
        //              交换机
        //              手机
        searchQueryBuilder.addAggregation(
                // AggregationBuilders聚合条件构造器
                // terms("categoryName")：给列取别名
                // field("categoryName.keyword")：
                //      categoryName字段名称
                //      .keyword便于聚合搜索：term 查询的时候，由于是精准匹配，所以查询的关键字在es上的类型，必须是keyword而不能是text
                // 如果不加.keyword会出错：Elasticsearch报错：exception [type=search_phase_execution_exception, reason=all shards failed]
                // size 指定查询结果的数量 默认是10个
                AggregationBuilders
                        .terms("categoryName")
                        .field("categoryName.keyword")
                        .size(100)
        );

        // 根据品牌名称对结果集分组： [华为，小米，中心，苹果]
        searchQueryBuilder.addAggregation(
                // AggregationBuilders聚合条件构造器
                // terms("brandName")：给列取别名
                // field("brandName.keyword")：
                //      brandName字段名称
                //      .keyword便于聚合搜索：term 查询的时候，由于是精准匹配，所以查询的关键字在es上的类型，必须是keyword而不能是text
                // 如果不加.keyword会出错：Elasticsearch报错：exception [type=search_phase_execution_exception, reason=all shards failed]
                // size 指定查询结果的数量 默认是10个
                AggregationBuilders
                        .terms("brandName")
                        .field("brandName.keyword")
                        .size(100)
        );

        // 根据品牌名称对结果集分组： [华为，小米，中心，苹果]
        searchQueryBuilder.addAggregation(
                // AggregationBuilders聚合条件构造器
                // terms("brandName")：给列取别名
                // field("brandName.keyword")：
                //      brandName字段名称
                //      .keyword便于聚合搜索：term 查询的时候，由于是精准匹配，所以查询的关键字在es上的类型，必须是keyword而不能是text
                // 如果不加.keyword会出错：Elasticsearch报错：exception [type=search_phase_execution_exception, reason=all shards failed]
                // size 指定查询结果的数量 默认是10个
                AggregationBuilders
                        .terms("spec")
                        .field("spec.keyword")
                        .size(100)
        );

        // 分页：默认第1页的100条数据
        searchQueryBuilder.withPageable(PageRequest.of(0, 100));
//    }

        //========================过滤查询 开始=====================================
        BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();

        if (searchParamMap != null) {
            for (String key : searchParamMap.keySet()) {//{ brand:"",category:"",spec_网络:"电信4G"}
                if (key.startsWith("spec_")) {
                    //截取规格的名称
                    boolQueryBuilder.filter(QueryBuilders.termQuery("specMap." + key.substring(5) + ".keyword", searchParamMap.get(key)));
                }
            }
        }

        String category = searchParamMap.get("category");
        if (!StringUtils.isEmpty(category)) {
            boolQueryBuilder.filter(QueryBuilders.termQuery("categoryName", category));
        }

        String brand = searchParamMap.get("brand");
        if (!StringUtils.isEmpty(brand)) {
            boolQueryBuilder.filter(QueryBuilders.termQuery("brandName", brand));
        }

        // 过滤查询
        searchQueryBuilder.withFilter(boolQueryBuilder);
        //========================过滤查询 结束=====================================

        // 搜索条件构造器构建：NativeSearchQuery
        NativeSearchQuery searchQuery = searchQueryBuilder.build();

        // 执行搜索，获取封装响应数据结果的SearchHits集合
        SearchHits<SkuInfo> searchHits = elasticsearchRestTemplate.search(searchQuery, SkuInfo.class);
        /*
         * 获取聚合后的以categoryName分组的分类名称集合
         * searchHits.getAggregations() 获取的是Aggregations集合
         * get("skuCategoryGroup") 获取指定categoryName域的分类名称集合数据 eg:[手机,家用电器,手机配件]
         * Aggregation ---> StringTerms 转换成子类
         */
        // 从Terms中获取分类名称集合
        // 注意:当用户选择(点击)了某个分类,将该分类作为搜索条件,这种情况下则不需要再对分类进行分组搜索,因为分组搜索的数据是用于显示分类搜索条件的,不需要重复展示
        // Terms ：注意这里是巨型踩坑，在ES7之前可以使用StringTerms，但是7之后，如果出现类型转换错误，建议使用Terms替代StringTerms
        // searchParamMap -> brand
        Terms categoryTerms = searchHits.getAggregations().get("categoryName");
        List<String> categoryList = this.getResultListByTerms(categoryTerms);

        // 从Terms中获取品牌名称集合
        // 注意:当用户选择(点击)了某个品牌,将该品牌作为搜索条件,这种情况下则不需要再对品牌进行分组搜索,因为分组搜索的数据是用于显示品牌搜索条件的,不需要重复展示
        // searchParamMap -> brand
        Terms BrandTerms = searchHits.getAggregations().get("brandName");
        List<String> brandList = this.getResultListByTerms(BrandTerms);

        Terms SpecTerms = searchHits.getAggregations().get("spec");
        // 获取spec规格域集合
        Map<String, Set<String>> specMap = this.getResultMapByTerms(SpecTerms);

        // 对SearchHits集合进行分页封装
        SearchPage<SkuInfo> searchPageFor = SearchHitSupport.searchPageFor(searchHits, searchQuery.getPageable());

        // 总记录数
        long totalElements = searchPageFor.getTotalElements();
        // 总页数
        int totalPages = searchPageFor.getTotalPages();
        // 当前页数
        int currentPage = searchPageFor.getPageable().getPageNumber();
        // 当前页总记录数
        int currentPageRows = searchPageFor.getPageable().getPageSize();

        // 获取所需SkuInfo集合数据内容
        List<SearchHit<SkuInfo>> content = searchPageFor.getContent();

        // 解析并再封装数据
        // 封装一个Map 存储所有数据，并返回
        HashMap<String, Object> resultMap = new HashMap<>();
        resultMap.put("totalPage", totalPages);// 总页数
        resultMap.put("total", totalElements);// 总记录数
        resultMap.put("currentPage", currentPage + 1);// 当前页
        resultMap.put("currentPageRows", currentPageRows);// 当前页总记录数
        resultMap.put("categoryList", categoryList);// 商品分类名称数据集合
        resultMap.put("brandList", brandList);// 商品分类名称数据集合
        resultMap.put("specMap", specMap);// 商品分类名称数据集合
        resultMap.put("rows", content);// 商品SkuInfo数据集合

        return resultMap;
    }

    /**
     * @param terms
     * @return
     */
    @Deprecated // 该方法不再使用，仅供与优化后的方法进行对比
    private Map<String, Set<String>> getResultMapByTerms(Terms terms) {

        // key :规格的名称
        // value :规格名称对应的选项的多个值集合set
        Map<String, Set<String>> specMap = new HashMap<String, Set<String>>();
        Set<String> specValues = new HashSet<String>();

        // 1.获取封装在terms中的商品spec规格集合
        if (terms != null) {
            for (Terms.Bucket bucket : terms.getBuckets()) {
                // 2.遍历terms.getBuckets(),逐行获取商品规格spec数据(json字符串类型)
                // spec :{"手机屏幕尺寸":"5.5寸","网络":"电信4G","颜色":"白","测试":"s11","机身内存":"128G","存储":"16G","像素":"300万像素"}
                String keyAsString = bucket.getKeyAsString();

                // 3.每循环一次就将json串类型的spec数据转换成Map<String, String>类型  key :规格的名称  value:规格名对应的选项的单个值
                Map<String, String> map = JSON.parseObject(keyAsString, Map.class);
                // 4.遍历上面一步转换为Map<String, String>类型的商品规格spec
                for (Map.Entry<String, String> stringStringEntry : map.entrySet()) {
                    //
                    String key = stringStringEntry.getKey();// 规格名称  eg:手机屏幕尺寸
                    String value = stringStringEntry.getValue();// 规格的名称对应的单个选项值 eg:5.5寸

                    // 先从最上面声明的specMap中 根据spec规格名称(key),获取该规格名称对应的商品参数集合(HashSet<String>类型的value)
                    specValues = specMap.get(key);
                    // 如果specValues不存在则新new一个
                    if (specValues == null) {
                        specValues = new HashSet<>();
                    }
                    // 将本次循环,根据商品规格名称(key)而获取到的单个规格参数存入HashSet(HashSet可以去重复!)
                    specValues.add(value);
                    // 5.将specValues放回specMap中去
                    specMap.put(key, specValues);
                }
            }
        }
        return specMap;
    }

    /**
     * 从Terms中获取封装数据的结果集
     */
    @Deprecated // 该方法不再使用，仅供与优化后的方法进行对比
    private List<String> getResultListByTerms(Terms terms) {
        List<String> resultList = new ArrayList<>();

        if (terms != null) {
            for (Terms.Bucket bucket : terms.getBuckets()) {
                String keyAsString = bucket.getKeyAsString();// 分组的值（分类名称/品牌名称）
                resultList.add(keyAsString);
            }
        }
        return resultList;
    }

    /**
     * 关键字检索(优化后的搜索方法)
     *
     * @param searchMap
     * @return
     */
    @Override
    public Map<String, Object> search(Map<String, String> searchMap) {
        // 1.封装检索条件(后期有多个检索条件，专门封装一个方法)
        NativeSearchQueryBuilder builder = builderBasicQuery(searchMap);
        // 2.根据关键字检索,获取改关键字下的商品信息
        Map<String, Object> resultMap = searchForPage(builder);
        // 3.商品分类列表
//        List<String> categoryList = searchCategoryList(builder);
//        resultMap.put("categoryList", categoryList);
        // 4.品牌分类列表查询
//        List<String> brandList = searchBrandList(builder);
//        resultMap.put("brandList", brandList);
        // 获取数据的总条数
        String totalElements = resultMap.get("TotalElements").toString();
        int totalSize = Integer.parseInt(totalElements);
        if (totalSize <= 0) {
            //判断totalSize是否小于等于0，如果小于等于0会报角标越界异常，需要给totalSize设置默认值防止报错
            totalSize = 10000;
        }
        // 5.统计规格分类列表
//        Map<String, Set<String>> specList = searchSpecList(builder,totalSize);
//        resultMap.put("specList", specList);
        // 6.将检索的结果封装到map中
        Map<String, Object> map = searchGroupList(builder, totalSize);
        resultMap.putAll(map);
        return resultMap;
    }

    /**
     * 统计规格分类列表查询, 品牌分类列表查询 ,商品分类分组统计实现(封装一个方法返回所有检索条件结果返回)
     *
     * @param builder
     * @return
     */
    private Map<String, Object> searchGroupList(NativeSearchQueryBuilder builder, int totalSize) {
        // 聚合查询   (分类)                                       别名                对应kibana中的字段
        builder.addAggregation(AggregationBuilders.terms("skuCategpryName").field("categoryName.keyword").size(totalSize));
        // 聚合查询   (品牌)                                       别名                对应kibana中的字段
        builder.addAggregation(AggregationBuilders.terms("skuBrandName").field("brandName.keyword").size(totalSize));
        // 聚合查询   (品牌)                                       别名                对应kibana中的字段
        builder.addAggregation(AggregationBuilders.terms("skuSpec").field("spec.keyword").size(totalSize));
        // 分组结果集
        SearchHits<SkuInfo> searchHits = elasticsearchRestTemplate.search(builder.build(), SkuInfo.class);
        // 对SearchHits集合进行分页封装
        SearchPage<SkuInfo> page = SearchHitSupport.searchPageFor(searchHits, builder.build().getPageable());

        //处理结果集
        Aggregations aggregations = page.getSearchHits().getAggregations();
        // 统计分类
        List<String> categoryList = getGroupList(aggregations, "skuCategpryName");
        // 统计品牌
        List<String> brandList = getGroupList(aggregations, "skuBrandName");
        // 统计规格
        List<String> spceList = getGroupList(aggregations, "skuSpec");
        // 将统计规格的List结果集转成Map返回
        Map<String, Set<String>> specmap = pullMap(spceList);
        // 将所有的数据封装Map
        Map<String, Object> map = new HashMap<>();
        map.put("categoryList", categoryList);
        map.put("brandList", brandList);
        map.put("specMap", specmap);
        // 返回最终结果集
        return map;
    }

    /**
     * 处理聚合查询(分类，品牌，品牌)结果集
     *
     * @param
     * @return
     */
    private List<String> getGroupList(Aggregations aggregations, String groupName) {
        Terms terms = aggregations.get(groupName);
        List<String> resultList = new ArrayList<>();

        if (terms != null) {
            for (Terms.Bucket bucket : terms.getBuckets()) {
                String keyAsString = bucket.getKeyAsString();// 分组的值（分类名称/品牌名称）
                resultList.add(keyAsString);
            }
        }
        return resultList;
    }

    /**
     * 处理规格数据封装Map
     *
     * @param list
     * @return
     */
    private Map<String, Set<String>> pullMap(List<String> list) {
        Map<String, Set<String>> map = new HashMap<>();
        for (String spec : list) {
            // 将字符JSON数据转Map
            Map<String, String> specMap = JSON.parseObject(spec, Map.class);
            // 遍历map
            Set<Map.Entry<String, String>> entrySet = specMap.entrySet();
            for (Map.Entry<String, String> entry : entrySet) {
                // 电视音响效果":
                String key = entry.getKey();
                // 小影院...
                String value = entry.getValue();
                // value是多个且不能重复使用Set集合存储
                // 首先判断map中是否有set
                Set<String> set = map.get(key);
                if (set == null) {
                    // 判断set是否为空，如果是空就new HashSet
                    set = new HashSet<>();
                }
                // set不为空就直接往里面添加数据
                set.add(value);
                map.put(key, set);
            }
        }
        return map;
    }

    /**
     * 根据关键字进行检索
     *
     * @param builder
     * @return
     */
    private Map<String, Object> searchForPage(NativeSearchQueryBuilder builder) {
        // 关键字的高亮显示
        // 继续封装检索条件
        HighlightBuilder.Field field = new HighlightBuilder.Field("name");  //sku的name如果有关键字就进行高亮
        field.preTags("<font color='red'>");    // 开始标签
        field.postTags("</font>");              // 结束标签
        field.fragmentSize(100);                // 显示的字符个数
        builder.withHighlightFields(field);

        NativeSearchQuery build = builder.build();
        //AggregatedPage<SkuInfo> page = elasticsearchTemplate.queryForPage(build, SkuInfo.class);
        // 分组结果集
        SearchHits<SkuInfo> searchHits = elasticsearchRestTemplate.search(builder.build(), SkuInfo.class);
        // 对SearchHits集合进行分页封装
        SearchPage<SkuInfo> page = SearchHitSupport.searchPageFor(searchHits, builder.build().getPageable());

        // 取出高亮的结果数据，在该对象中
        // 遍历: 对返回的内容进行处理(高亮字段替换原来的字段)
        for(SearchHit<SkuInfo> searchHit:searchHits){
            // 获取searchHit中的高亮内容
            Map<String, List<String>> highlightFields = searchHit.getHighlightFields();
            // 将高亮的内容填充到content中
            searchHit.getContent().setName(highlightFields.get("name")==null ? searchHit.getContent().getName():highlightFields.get("name").get(0));
        }

        Map<String, Object> map = new HashMap<>();
        // 商品结果集
        map.put("rows", page.getContent());
        //总条数
        map.put("TotalElements", page.getTotalElements());
        //总页数
        map.put("TotalPages", page.getTotalPages());
        // 分页当前页码
        map.put("pageNum", build.getPageable().getPageNumber() + 1);
        // 每页显示条数
        map.put("pageSize", build.getPageable().getPageSize());

        return map;
    }

    /**
     * 此方法用于封装检索条件NativeSearchQueryBuilder
     *
     * @param searchMap
     * @return
     */
    private NativeSearchQueryBuilder builderBasicQuery(Map<String, String> searchMap) {
        // 封装检索条件
        NativeSearchQueryBuilder builder = new NativeSearchQueryBuilder();
        // 添加过滤条件
        BoolQueryBuilder boolBuilder = new BoolQueryBuilder();
        if (searchMap != null) {

            // 1.根据关键字检索
            String keywords = searchMap.get("keywords");
            if (!StringUtils.isEmpty(keywords)) {
                builder.withQuery(QueryBuilders.matchPhraseQuery("name", keywords));
            }

            // 继续拼接条件
            // 2.根据商品分类过滤
            String category = searchMap.get("category");
            if (!StringUtils.isEmpty(category)) {
                boolBuilder.must(QueryBuilders.matchPhraseQuery("categoryName", category));
            }

            // 3.根据商品品牌过滤
            String brand = searchMap.get("brand");
            if (!StringUtils.isEmpty(brand)) {
                boolBuilder.must(QueryBuilders.matchPhraseQuery("brandName", brand));
            }

            // 4.根据商品规格过滤(选择的规格有多个)
            // ::spec_屏幕尺寸 ：5.7, spec_内存 ：40G
            Set<String> keys = searchMap.keySet();
            for (String key : keys) {
                // 判断规格条件是否是spec_开头的
                if (key.startsWith("spec_")) {
                    String value = searchMap.get(key).replace("\\", "");
                    boolBuilder.must(QueryBuilders.matchQuery("specMap." + key.substring(5) + ".keyword", value));
                }
            }

            // 5.根据商品价格过滤(区间段)
            String price = searchMap.get("price");
            if (!StringUtils.isEmpty(price)) {
                // 页面传的价格式(min ~ max / >price /  <price)
                String[] priceArray = price.split("-");
                // 如果传的价格参数是一个就大于(>=)查询
                boolBuilder.must(QueryBuilders.rangeQuery("price").gte(priceArray[0]));
                if (priceArray.length > 1) {
                    // 如果传的价格参数是两个就小于(<=)查询
                    boolBuilder.must(QueryBuilders.rangeQuery("price").lte(priceArray[1]));
                }
            }

            // 6.进行排序查询(排序字段,ASC DESC)
            // 排序的字段
            String sortField = searchMap.get("sortField");
            // 排序的规则(ASC DESC)
            String sortRule = searchMap.get("sortRule");
            if (!StringUtils.isEmpty(sortField)) {
                builder.withSort(SortBuilders.fieldSort(sortField).order(SortOrder.valueOf(sortRule)));
            }
        }
        // 7. 将过滤的条件都加到builder中NativeSearchQueryBuilder
        builder.withFilter(boolBuilder);

        // 8. 添加分页条件 age1:当前页（page）   age2：每页显示数据（size）
        String page = searchMap.get("pageNum");
        if (StringUtils.isEmpty(page)) {
            // 默认起始页为第一页
            page = "1";
        }
        int pageNum = Integer.parseInt(page);
        // 动态获得前端传
        String size = searchMap.get("size");
        // 默认一页显示20条数据
        if (StringUtils.isEmpty(size)) {
            size = "20";
        }
        int pageSize = Integer.parseInt(size);
        Pageable pageable = PageRequest.of(pageNum - 1, pageSize);
        builder.withPageable(pageable);
        return builder;
    }
}
